home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 60 / IOPROG_60.ISO / soft / c++ / gsl-1.1.1-setup.exe / {app} / src / rng / benchmark.c next >
Encoding:
C/C++ Source or Header  |  2002-04-18  |  3.6 KB  |  140 lines
  1. /* rng/benchmark.c
  2.  * 
  3.  * Copyright (C) 1996, 1997, 1998, 1999, 2000 James Theiler, Brian Gough
  4.  * 
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or (at
  8.  * your option) any later version.
  9.  * 
  10.  * This program is distributed in the hope that it will be useful, but
  11.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * General Public License for more details.
  14.  * 
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19.  
  20. #include <config.h>
  21. #include <time.h>
  22. #include <stdio.h>
  23. #include <gsl/gsl_rng.h>
  24. #include <gsl/gsl_errno.h>
  25.  
  26. void benchmark (const gsl_rng_type * T);
  27.  
  28. #define N  1000000
  29. int isum;
  30. double dsum;
  31.  
  32. int
  33. main (void)
  34. {
  35.  
  36.   benchmark(gsl_rng_borosh13);
  37.   benchmark(gsl_rng_cmrg);
  38.   benchmark(gsl_rng_coveyou);
  39.   benchmark(gsl_rng_fishman18);
  40.   benchmark(gsl_rng_fishman20);
  41.   benchmark(gsl_rng_fishman2x);
  42.   benchmark(gsl_rng_gfsr4);
  43.   benchmark(gsl_rng_knuthran);
  44.   benchmark(gsl_rng_knuthran2);
  45.   benchmark(gsl_rng_lecuyer21);
  46.   benchmark(gsl_rng_minstd);
  47.   benchmark(gsl_rng_mrg);
  48.   benchmark(gsl_rng_mt19937);
  49.   benchmark(gsl_rng_r250);
  50.   benchmark(gsl_rng_ran0);
  51.   benchmark(gsl_rng_ran1);
  52.   benchmark(gsl_rng_ran2);
  53.   benchmark(gsl_rng_ran3);
  54.   benchmark(gsl_rng_rand);
  55.   benchmark(gsl_rng_rand48);
  56.   benchmark(gsl_rng_random128_bsd);
  57.   benchmark(gsl_rng_random128_glibc2);
  58.   benchmark(gsl_rng_random128_libc5);
  59.   benchmark(gsl_rng_random256_bsd);
  60.   benchmark(gsl_rng_random256_glibc2);
  61.   benchmark(gsl_rng_random256_libc5);
  62.   benchmark(gsl_rng_random32_bsd);
  63.   benchmark(gsl_rng_random32_glibc2);
  64.   benchmark(gsl_rng_random32_libc5);
  65.   benchmark(gsl_rng_random64_bsd);
  66.   benchmark(gsl_rng_random64_glibc2);
  67.   benchmark(gsl_rng_random64_libc5);
  68.   benchmark(gsl_rng_random8_bsd);
  69.   benchmark(gsl_rng_random8_glibc2);
  70.   benchmark(gsl_rng_random8_libc5);
  71.   benchmark(gsl_rng_random_bsd);
  72.   benchmark(gsl_rng_random_glibc2);
  73.   benchmark(gsl_rng_random_libc5);
  74.   benchmark(gsl_rng_randu);
  75.   benchmark(gsl_rng_ranf);
  76.   benchmark(gsl_rng_ranlux);
  77.   benchmark(gsl_rng_ranlux389);
  78.   benchmark(gsl_rng_ranlxd1);
  79.   benchmark(gsl_rng_ranlxd2);
  80.   benchmark(gsl_rng_ranlxs0);
  81.   benchmark(gsl_rng_ranlxs1);
  82.   benchmark(gsl_rng_ranlxs2);
  83.   benchmark(gsl_rng_ranmar);
  84.   benchmark(gsl_rng_slatec);
  85.   benchmark(gsl_rng_taus);
  86.   benchmark(gsl_rng_transputer);
  87.   benchmark(gsl_rng_tt800);
  88.   benchmark(gsl_rng_uni);
  89.   benchmark(gsl_rng_uni32);
  90.   benchmark(gsl_rng_vax);
  91.   benchmark(gsl_rng_waterman14);
  92.   benchmark(gsl_rng_zuf);
  93.  
  94.   return 0;
  95. }
  96.  
  97. void
  98. benchmark (const gsl_rng_type * T)
  99. {
  100.   int start, end;
  101.   int i = 0, d = 0 ;
  102.   double t1, t2;
  103.  
  104.   gsl_rng *r = gsl_rng_alloc (T);
  105.  
  106.   start = clock ();
  107.   do
  108.     {
  109.       int j;
  110.       for (j = 0; j < N; j++)
  111.     isum += gsl_rng_get (r);
  112.  
  113.       i += N;
  114.       end = clock ();
  115.     }
  116.   while (end < start + CLOCKS_PER_SEC/10);
  117.  
  118.   t1 = (end - start) / (double) CLOCKS_PER_SEC;
  119.  
  120.   start = clock ();
  121.   do
  122.     {
  123.       int j;
  124.       for (j = 0; j < N; j++)
  125.     dsum += gsl_rng_uniform (r);
  126.  
  127.       d += N;
  128.       end = clock ();
  129.     }
  130.   while (end < start + CLOCKS_PER_SEC/10);
  131.  
  132.   t2 = (end - start) / (double) CLOCKS_PER_SEC;
  133.  
  134.  
  135.   printf ("%6.0f k ints/sec, %6.0f k doubles/sec, %s\n",
  136.       i / t1 / 1000.0, d / t2 / 1000.0, gsl_rng_name (r));
  137.  
  138.   gsl_rng_free (r);
  139. }
  140.